A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Investigating data-flow coverage of classes using evolutionary algorithms

It is not unusual for a software development organization to expend 40% of total project effort on testing, which call be a very laborious and time-consuming process. Therefore, there is a big necessity for test automation. This paper describes an approach to automatically generate test-data for 00 software exploiting a Genetic Algorithm (GA) to achieve high levels of data-flow (d-u) coverage. A proof-of-concept tool is presented. The experimental results from testing six Java classes helped us identify three categories of problematic test targets, and suggest that in the future full d-u coverage with a reasonable computational cost may be possible if we overcome these obstacles

The Java system dependence graph

The Program Dependence Graph was introduced by Ottenstein and Ottenstein in 1984 [14]. It was suggested to be a suitable internal program representation for monolithic programs, for the purpose of carrying out certain software engineering operations such as slicing and the computation of program metrics. Since then, Horwitz et al. have introduced the multi-procedural equivalent System Dependence Graph [9]. Many authors have proposed object-oriented dependence graph construction approaches [11, 10, 20, 12]. Every approach provides its own benefits, some of which are language specific. This paper is based on Java and combines the most important benefits from a range of approaches. The result is a Java System Dependence Graph, which summarises the key benefits offered by different approaches and adapts them (if necessary) to the Java language

Understanding object-oriented source code from the behavioural perspective

Comprehension is a key activity that underpins a variety of software maintenance and engineering tasks. The task of understanding object-oriented systems is hampered by the fact that the code segments that are related to a user-level function tend to be distributed across the system. We introduce a tool-supported code extraction technique that addresses this issue. Given a minimal amount of information about a behavioural element of the system that is of interest (such as a use-case), it extracts a trail of the methods (and method invocations) through the system that are needed in order to achieve an understanding of the implementation of the element of interest. We demonstrate the feasibility of our approach by implementing it as part of a code extraction tool, presenting a case study and evaluating the approach and tool against a set of established criteria for program comprehension tools

Investigating effort prediction of web-based applications using CBR on the ISBSG dataset

As web-based applications become more popular and more sophisticated, so does the requirement for early accurate estimates of the effort required to build such systems. Case-based reasoning (CBR) has been shown to be a reasonably effective estimation strategy, although it has not been widely explored in the context of web applications. This paper reports on a study carried out on a subset of the ISBSG dataset to examine the optimal number of analogies that should be used in making a prediction. The results show that it is not possible to select such a value with confidence, and that, in common with other findings in different domains, the effectiveness of CBR is hampered by other factors including the characteristics of the underlying dataset (such as the spread of data and presence of outliers) and the calculation employed to evaluate the distance function (in particular, the treatment of numeric and categorical data)

Improving the viability of mental models held by novice programmers

Recent research has found that many novice programmers often hold non-viable mental models of basic programming concepts such as assignment and object reference. This paper proposes a constructivist-based teaching model, integrating a cognitive conflict strategy with program visualization, with the aim of improving novice programmers’ mental models. The results of a preliminary empirical study suggest that, for the relatively straightforward concept of assignment, tight integration of program visualization with a cognitive conflict event that highlights a student’s inappropriate understanding can help improve students’ non-viable mental models. 14 out of 18 participants who held non-viable mental models of the assignment process successfully changed their model to be viable as a result of the proposed teaching model

Perceived financial barriers and the start-up decision: An econometric analysis of gender differences using GEM data

Although accessing finance is key to the foundation of any business, particular concerns have been expressed about the ability of UK women-owned firms to obtain external finance. In this paper we use an econometric approach to explore the effect of perceptions of financial barriers to start-up on the start-up decision itself. Our analysis is based on the Global Entrepreneurship Monitor (GEM) UK 2004 database. Standardising for a range of individual characteristics, we find that women are around 7.4 per cent more likely to perceive financial barriers to business start-up than men. As perceptions of financial barriers are linked negatively to the start-up decision, stronger perceptions of financial barriers among women are having a disproportionate effect on women’s start-up decisions. However, being female also has an additional negative effect on the start-up decision, not linked to financial barriers. Policy responses, therefore, need to take into account the demand-side with the aim of countering the more negative perceptions of start-up finance among potential women entrepreneurs. Mentoring and confidence building programmes are obvious possibilities. We also find support for the value of university and college-based work experience programmes. [PUBLISHED ABSTRACT]Finance; entrepreneurship; start-up; SME; gender; women

Organizing the innovation process : complementarities in innovation networking

This paper contributes to the developing literature on complementarities in organizational design. We test for the existence of complementarities in the use of external networking between stages of the innovation process in a sample of UK and German manufacturing plants. Our evidence suggests some differences between the UK and Germany in terms of the optimal combination of innovation activities in which to implement external networking. Broadly, there is more evidence of complementarities in the case of Germany, with the exception of the product engineering stage. By contrast, the UK exhibits generally strong evidence of substitutability in external networking in different stages, except between the identification of new products and product design and development stages. These findings suggest that previous studies indicating strong complementarity between internal and external knowledge sources have provided only part of the picture of the strategic dilemmas facing firms

Applying inspection to object-oriented software

The benefits of the object-oriented paradigmare widely cited. At the same time, inspection is deemed to be the most cost-effective means of detecting defects in software products. Why then, is there no published experience, let alone quantitative data, on the application of inspection to object-oriented systems? We describe the facilities of the object-oriented paradigm and the issues that these raise when inspecting object-oriented code. Several problems are caused by the disparity between the static code structure and its dynamic runtime behaviour. The large number of small methods in object-oriented systems can also cause problems. We then go on to describe three areas which may help mitigate problems found. Firstly, the use of various programming methods may assist in making object-oriented code easier to inspect. Secondly, improved program documentation can help the inspector understand the code which is under inspection. Finally, tool support can help the inspector to analyse the dynamic behaviour of the code. We conclude that while both the object-oriented paradigm and inspection provide excellent benefits on their own, combining the two may be a difficult exercise, requiring extensive support if it is to be successful

An empirical study evaluating depth of inheritance on the maintainability of object-oriented software

This empirical research was undertaken as part of a multi-method programme of research to investigate unsupported claims made of object-oriented technology. A series of subject-based laboratory experiments, including an internal replication, tested the effect of inheritance depth on the maintainability of object-oriented software. Subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of three levels of inheritance depth and equivalent object-based software with no inheritance. This was then replicated with more experienced subjects. In a second experiment of similar design, subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of five levels of inheritance depth and the equivalent object-based software. The collected data showed that subjects maintaining object-oriented software with three levels of inheritance depth performed the maintenance tasks significantly quicker than those maintaining equivalent object-based software with no inheritance. In contrast, subjects maintaining the object-oriented software with five levels of inheritance depth took longer, on average, than the subjects maintaining the equivalent object-based software (although statistical significance was not obtained). Subjects' source code solutions and debriefing questionnaires provided some evidence suggesting subjects began to experience diffculties with the deeper inheritance hierarchy. It is not at all obvious that object-oriented software is going to be more maintainable in the long run. These findings are sufficiently important that attempts to verify the results should be made by independent researchers